py3

class HelloWorld:
  def __init__(s,p):print(p)

HelloWorld("print")

print

py3

import pytz
import datetime

def get_time_in_timezone(timezone):
  tz = pytz.timezone(timezone)
  utc_now = datetime.datetime.utcnow()
  tz_now = utc_now.astimezone(tz)
  hour = tz_now.hour
  minute = tz_now.minute
  time_dict = {"hour": hour, "minute": minute}
  return time_dict

timezone = "Pacific/Chatham"
time_dict = get_time_in_timezone(timezone)
total_minutes = time_dict["hour"] * 60 + time_dict["minute"]
formatted_time = "{:02d}:{:02d}".format(total_minutes // 100, total_minutes % 100)
print(formatted_time)

06:69

py3

def a(s,e):
 r=""
 for n in range(s,e+1):
  m=str(n);l=len(m);f=0
  for i in range(len(r)-l+1):
   if r[i:i+l]==m:f=1;break
  if not f:r+=m
 return r
print(a(0,100))

01234567891011131415161718192021222425262728293032333536373839404344464748495054555758596065666869707677798087889099100

c

#include <stdio.h>

int ((((((((((main))))))))))(){
    printf("Lisp sucks!");
    return 0;
}

Lisp sucks!

py3

def even_or_odd(num):
  return "eovdedn"[num%2::2]

tests = [-20, -1, 0, 1, 20, 33]
print(*map(even_or_odd, tests))

even odd even odd even odd

import unicodedata as ud
g="Generation";gens=[(1883,1900,f"Lost {g}"),(1901,1927,f"Greatest {g}"),(1928,1945,f"Silent {g}"),(1946,1964,"Boomer"),(1965,1980,f"{g} X"),(1981,1996,f"{g} Y/Millennial"),(1997,2012,f"{g} Z")]
def get_gen(birthyear):
 for min,max,gen in gens:
  if min<=birthyear<=max:
   gen_info = f"{birthyear}: {gen}"
   if 1992 <= birthyear <= 2000:
    gen_info += "/Zillennial"
   return gen_info
 return f"{birthyear}: {g} {[ud.name(chr(945+i+(1 if 945+i>=962 else 0))).split()[-1].title() for i,min in enumerate(range(2013,2397,16)) if min<=birthyear<=min+15][0]}"

print(*map(get_gen, [1883,1900,1901,1927,1928,1945,1946,1964,1965,1980,1981,1992,1996,1997,2000,2010,2012,2013,2269,2396]), sep="\n")

1883: Lost Generation
1900: Lost Generation
1901: Greatest Generation
1927: Greatest Generation
1928: Silent Generation
1945: Silent Generation
1946: Boomer
1964: Boomer
1965: Generation X
1980: Generation X
1981: Generation Y/Millennial
1992: Generation Y/Millennial/Zillennial
1996: Generation Y/Millennial/Zillennial
1997: Generation Z/Zillennial
2000: Generation Z/Zillennial
2010: Generation Z
2012: Generation Z
2013: Generation Alpha
2269: Generation Rho
2396: Generation Omega

py3

from random import randrange as r
d = 3
for x in range(1000):
 a = [chr(65+r(26))for _ in range(d)]
 if a == [*'ZAC']:print(x, *a)

152 Z A C

py3

a = 1
match a:
  case 0: print('😎')
  case 1: print('😮')

😮

py3

a = 2
match a:
  case 0: print('owo') 
  case 1: print('😮')
  case _: print('🤔')

🤔

python

# Unicode Secure Password Generator v1.0
import secrets
import unicodedata

def is_printable_unicode(char):
    """Check if a character is printable and not a whitespace character."""
    category = unicodedata.category(char)
    # Categories starting with 'C' are control characters, 'Z' are separators including spaces, 'M' are marks
    if category.startswith(('C', 'Z', 'M')):
        return False
    return True

def generate_printable_unicode_list(length=16):
    printable_unicode_chars = []
    
    while len(printable_unicode_chars) < length:
        # Generate a random Unicode code point
        random_code_point = secrets.randbelow(0x110000)  # Unicode range: 0 to 0x10FFFF
        
        try:
            char = chr(random_code_point)
            if is_printable_unicode(char):
                printable_unicode_chars.append(char)
        except ValueError:
            # If the code point is not a valid Unicode character, skip it
            continue
    
    return printable_unicode_chars

# Generate the list of printable Unicode characters
printable_unicode_chars = generate_printable_unicode_list()

# Print the resulting list of Unicode characters
print("".join(printable_unicode_chars))

䣢Ⲇ𐬺葉𤻙𤰚繁𞺍𦼩𤦟鍜塧𪵴𮠺𫙟😎

import math

# Constants
NANOSECONDS_IN_A_SECOND = 1_000_000_000
SECONDS_IN_A_YEAR = 60 * 60 * 24 * 365
NANOSECONDS_IN_A_YEAR = NANOSECONDS_IN_A_SECOND * SECONDS_IN_A_YEAR
MAX_YEARS = 30

# Initial value of nanoseconds
nanoseconds = 1

while True:
    # Calculate the corresponding years for the current nanoseconds
    years = nanoseconds / NANOSECONDS_IN_A_YEAR
    
    # Check if the next doubling would exceed 30 years
    if 2 * nanoseconds / NANOSECONDS_IN_A_YEAR >= MAX_YEARS:
        break
    
    # Double the nanoseconds
    nanoseconds *= 2

# Print the results in scientific notation for nanoseconds and years with one decimal place
print(f"Nanoseconds milestone: {nanoseconds:.2e} ns")
print(f"Corresponding age in years: {years:.1f} years")

Nanoseconds milestone: 5.76e+17 ns
Corresponding age in years: 18.3 years

from datetime import datetime, timedelta

# Constants
NANOSECONDS_IN_A_SECOND = 1_000_000_000
SECONDS_IN_A_YEAR = 60 * 60 * 24 * 365
NANOSECONDS_IN_A_YEAR = NANOSECONDS_IN_A_SECOND * SECONDS_IN_A_YEAR

# Function to convert nanoseconds to a timedelta
def nanoseconds_to_timedelta(nanoseconds):
    seconds = nanoseconds // NANOSECONDS_IN_A_SECOND
    remaining_nanoseconds = nanoseconds % NANOSECONDS_IN_A_SECOND
    return timedelta(seconds=seconds, microseconds=remaining_nanoseconds / 1000)

# Input birth datetime
birth_datetime_str = input("Enter your birth datetime (YYYY-MM-DD HH:MM:SS): ")
birth_datetime = datetime.strptime(birth_datetime_str, "%Y-%m-%d %H:%M:%S")

# Current datetime
current_datetime = datetime.now()

# Initial value of nanoseconds and milestones
nanoseconds = 1
previous_milestone = birth_datetime
next_milestone = birth_datetime

# Loop to find the next milestone after the current datetime
while True:
    # Calculate the next potential milestone datetime
    next_milestone = birth_datetime + nanoseconds_to_timedelta(nanoseconds)
    
    # Check if the next milestone surpasses the current datetime
    if next_milestone > current_datetime:
        break
    
    # Update the previous milestone and double the nanoseconds
    previous_milestone = next_milestone
    nanoseconds *= 2

# Output the results
print(f"Previous milestone: {previous_milestone} (nanoseconds: {nanoseconds//2:.2e} ns)")
print(f"\nNext milestone: {next_milestone} (nanoseconds: {nanoseconds:.2e} ns)")

import math as m
YOUR_AGE = 30
YEAR_NS = 1e9 * 60 * 60 * 24 * 365
MS_NS = 2 ** m.floor(m.log2(YOUR_AGE * YEAR_NS))
print(f"Your previous nanoseconds milestone was at {MS_NS / YEAR_NS:.2f} years, next one is at {MS_NS * 2 / YEAR_NS:.2f}")

python

import datetime
import pytz
from collections import OrderedDict
from dateutil.relativedelta import relativedelta
import math as m
import time

class MilestoneCalculator:
    def __init__(self, birthdate_str, timezone_str):
        self.timezone = pytz.timezone(timezone_str)
        self.birthdate_utc = pytz.utc.localize(datetime.datetime.strptime(birthdate_str, "%Y-%m-%d %H:%M:%S"))
        self.birthdate_local = self.birthdate_utc.astimezone(self.timezone)

    def convert_and_calculate_milestones(self, nanoseconds):
        ns_per_microsecond = 1_000
        ns_per_second = 1e9

        seconds, remaining_ns = divmod(nanoseconds, ns_per_second)
        timedelta_value = datetime.timedelta(seconds=seconds, microseconds=remaining_ns // ns_per_microsecond)

        current_date = self.birthdate_local + timedelta_value
        result = OrderedDict()

        years = 0
        while current_date >= self.birthdate_local + relativedelta(years=years + 1):
            years += 1
        result['y'] = years

        months = 0
        while current_date >= self.birthdate_local + relativedelta(years=years, months=months + 1):
            months += 1
        result['m'] = months

        days = 0
        while current_date >= self.birthdate_local + relativedelta(years=years, months=months, days=days + 1):
            days += 1
        result['d'] = days

        delta = current_date - (self.birthdate_local + relativedelta(years=years, months=months, days=days))
        hours, remainder = divmod(delta.seconds, 3600)
        minutes, seconds = divmod(remainder, 60)

        result.update({'H': hours, 'M': minutes, 'S': seconds, 'ms': delta.microseconds // 1_000,
                       'us': delta.microseconds % 1_000, 'ns': remaining_ns % 1_000})

        return result, timedelta_value


    def print_age_and_milestones(self):
        current_time_local = datetime.datetime.now(pytz.utc).astimezone(self.timezone)
        current_ns = time.time_ns()
        age_ns = current_ns - int(self.birthdate_utc.timestamp() * 1e9)

        age_details, _ = self.convert_and_calculate_milestones(age_ns)
        age_str = ' '.join(f"{value}{key}" for key, value in age_details.items())

        MS_NS = 2 ** (age_ns.bit_length() - 1)
        previous_ns = MS_NS
        next_ns = MS_NS * 2

        prev_details, prev_timedelta = self.convert_and_calculate_milestones(previous_ns)
        prev_date = self.birthdate_local + prev_timedelta
        prev_date_str = prev_date.strftime("%Y-%m-%d %H:%M:%S.%f %Z")

        next_details, next_timedelta = self.convert_and_calculate_milestones(next_ns)
        next_date = self.birthdate_local + next_timedelta
        next_date_str = next_date.strftime("%Y-%m-%d %H:%M:%S.%f %Z")

        print(f"Current age in \"{self.timezone.zone}\":\n{age_str}\n\n"
              f"Previous milestone: {prev_date_str} (nanosecond age: {previous_ns:.2e} ns)\n\n"
              f"Next milestone: {next_date_str} (nanosecond age: {next_ns:.2e} ns)")

birthdate_str = "1990-01-01 00:00:00"
for timezone_str in ["Asia/Nicosia", "America/New_York"]:
    calculator = MilestoneCalculator(birthdate_str, timezone_str)
    calculator.print_age_and_milestones()
    print("\n")

Current age in "Asia/Nicosia":
34y 7m 0d 10H 55M 39S 137ms 929us 344.0ns

Previous milestone: 2008-04-08 01:59:12.303423 EET (nanosecond age: 5.76e+17 ns)

Next milestone: 2026-07-15 01:58:24.606846 EET (nanosecond age: 1.15e+18 ns)


Current age in "America/New_York":
34y 7m 0d 10H 55M 39S 140ms 795us 520.0ns

Previous milestone: 2008-04-07 18:59:12.303423 EST (nanosecond age: 5.76e+17 ns)

Next milestone: 2026-07-14 18:58:24.606846 EST (nanosecond age: 1.15e+18 ns)

python

print(chr(sum(range(ord(min(str(not())))))))

ඞ

python

import unicodedata as ud
e="💁🏽‍♀️"
print(*[f"{x} ({x.encode('unicode-escape').decode('utf8')}): {y}" for y,x in zip(map(ud.name, [*e]), [*e])],sep="\n")

💁 (\U0001f481): INFORMATION DESK PERSON
🏽 (\U0001f3fd): EMOJI MODIFIER FITZPATRICK TYPE-4
‍ (\u200d): ZERO WIDTH JOINER
♀ (\u2640): FEMALE SIGN
️ (\ufe0f): VARIATION SELECTOR-16

python

import datetime

current_time_str = "01:15"
start_cycle = 3
end_cycle = 6
sleep_latency = 20
cycle_length = 90

current_time = datetime.datetime.strptime(current_time_str, "%H:%M")
start_time = current_time + datetime.timedelta(minutes=sleep_latency)

for N in range(start_cycle, end_cycle + 1):
    alarm_time = start_time + datetime.timedelta(minutes=N * cycle_length)
    alarm_time_str = alarm_time.strftime("%H:%M")
    print(f"Cycle#: {N}, Alarm Set: {alarm_time_str}")

Cycle#: 3, Alarm Set: 06:05
Cycle#: 4, Alarm Set: 07:35
Cycle#: 5, Alarm Set: 09:05
Cycle#: 6, Alarm Set: 10:35